home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 076-100 / 092 / shar / parse.c < prev    next >
C/C++ Source or Header  |  1995-03-13  |  5KB  |  134 lines
  1. /* Parse.c
  2.  
  3.    Copyright (c) 1987 by F. G. Dufoe, III
  4.    All rights reserved.
  5.  
  6.    Permission is granted to redistribute this program provided the source
  7.    code is included in the distribution and this copyright notice is
  8.    unchanged.
  9.  
  10. */
  11.  
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include "Token.h"
  15.  
  16.  
  17. struct Token *
  18. parse(line, text)
  19.    /* This function parses a line of text.  The calling program passes it
  20.       two character pointers.  The first points to the null-terminated
  21.       string containing the line of text to be parsed.  The second points to
  22.       a buffer the calling program has defined for storing the text of the
  23.       tokens parse() gets.  Parse() returns a pointer to a linked list of
  24.       Token structures (Token structures are defined in Token.h). */
  25. char *line;
  26.    /* This points to the line of text to be parsed.  If it is NULL the
  27.       calling program is through with the list of Token structures and their
  28.       memory can be freed. */
  29. char *text;
  30.    /* This points to the area where token text will be stored.  Text from
  31.       all the tokens will be stored here, so it must be as long as the line
  32.       to be parsed. */
  33. {
  34.    struct Token *current;
  35.       /* This points to the current Token structure. */
  36.  
  37.    static struct Token *first = NULL;
  38.       /* This points to the beginning of the list of Token structures. */
  39.  
  40.    void freetokens(struct Token *);
  41.       /* This function walks the list of Token structures and frees their
  42.          memory. */
  43.  
  44.    TOKEN gettoken(char *, char *);
  45.       /* This function gets the next token from a character string. */
  46.  
  47.    TOKEN type;
  48.       /* This is the token type returned by gettoken(). */
  49.  
  50.    char word[100];
  51.       /* This array will be used by gettoken() to store the text of the
  52.          tokens it gets.  Only one token at a time will be stored here. */
  53.  
  54.  
  55.    if (line == NULL)
  56.       /* If the calling program passes a NULL pointer we'll free the memory
  57.          allocated for Token structures and return a NULL pointer. */
  58.    {
  59.       freetokens(first);
  60.       return(NULL);
  61.    }
  62.  
  63.    if (first == NULL)
  64.       /* No memory for Token structures has been allocated yet.  Allocate
  65.          the first one. */
  66.    {
  67.       if ((first = (struct Token *)malloc(sizeof(struct Token))) == NULL)
  68.          fatal("Parse: Could not allocate Token structure.");
  69.          /* If we can't allocate memory for a Token structure we can't
  70.             continue.  Notify the user and terminate. */
  71.       first->text = text;
  72.          /* We'll use the text buffer supplied by the calling program to
  73.             store the token text. */
  74.       first->next = NULL;
  75.          /* Until we have allocated another Token structure this one is the
  76.             end of the list. */
  77.    }
  78.  
  79.    current = first;
  80.       /* We'll start by using the first Token structure we allocated. */
  81.  
  82.    while ((type = gettoken(line, word)) != T_NL)
  83.       /* Until we get to the end of the line, keep asking for the next
  84.          token. */
  85.    {
  86.       current->type = type;
  87.          /* Save the type which gettoken() returned. */
  88.       strcpy (current->text, word);
  89.          /* Save the text which gettoken() returned. */
  90.       if (current->next == NULL)
  91.          /* If we don't already have another Token structure allocated let's
  92.             allocate one now to use for the next token. */
  93.       {
  94.          if ((current->next = (struct Token *)
  95.                               malloc(sizeof(struct Token))) == NULL)
  96.             fatal("Parse: Could not allocate Token structure.");
  97.                /* If we couldn't allocate the next Token structure we can't
  98.                   continue.  Notify the user and terminate. */
  99.          current->next->next = NULL;
  100.             /* Make the new structure the one at the end of the list by
  101.                setting its next pointer to NULL. */
  102.       }
  103.       current->next->text = current->text + strlen(word) + 1;
  104.          /* Advance the text pointer to the next available address in the
  105.             calling program's text buffer. */
  106.       current = current->next;
  107.          /* Make the next structure the current one. */
  108.    }
  109.    current->type = type;
  110.    *(current->text) = 0;
  111.    if (current->next != NULL)
  112.       /* If we have some unused Token structures in our list let's free them
  113.          now.  Since we use the same Token structure list over for
  114.          subsequent lines this can happen if a short line follows a long
  115.          one. */
  116.    {
  117.       freetokens(current->next);
  118.       current->next = NULL;
  119.    }
  120.    return(first);
  121. }
  122.  
  123.  
  124. void
  125. freetokens(head)
  126.      /* This function walks the list of Token structures and frees the
  127.         memory allocated for the structures. */
  128. struct Token *head;
  129. {
  130.      if (head->next != NULL)
  131.           freetokens(head->next);
  132.      free((char *)head);
  133. }
  134.